Since `_union` is only used in `Conjunction.__call__`, it makes sence to define it in `base.py` (where `Conjunction` is defined). Further, since `base.py` contains several classes, it makes sence to make `_union` a static method of specifically the `Conjunction` class. Lastly, since `Conjunction.__call__` is almost a trivial call to `_union`, it makes sense to have no `_union` method but to directly compute this union in the `__call__` method of `Conjunction`. This is kind of the opposite of a factorization, but it should enhance code readability since it limits the back-and-forth required to understand a piece of code.

- Since `dict_union` is only used in `stacks.py`, I think it's better to define it there. It makes less back-and-forth when reading the code, and it reduces the number of things that `_utils.py` has to contain.
- Also remove _ValueType from _utils.py since it is now unused

- It now only contains the _materialize function, which can hardly be moved to another file since grad, jac and stack depend on it.

- materialize is in a protected file _materialize.py, which means that only members of the local transform package can import from it. There is thus no point in make the materialize function itself protected. In fact, this would mean that the materialize function should not be used outside _materialize.py, while in fact, it has to be used in grad.py, jac.py, and stack.py.

- Same reason as materialize